"using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.UI;
 using System.Collections;
 using AL_Arcade.DialogueSystem.Scripts;
 using ALArcade.ArabicTMP;
 using TMPro;
 
 namespace AL_Arcade.DialogueSystem.Scripts
 {
     public class DialogueManager : MonoBehaviour
     {
         [Header("UI References")] [SerializeField]
         private Transform dialogueContainer;
 
         [SerializeField] private GameObject dialoguePrefabEN;
         [SerializeField] private GameObject dialoguePrefabAR;
         [SerializeField] private GameObject replyPrefab;
         [SerializeField] private GameObject replyPanel;
         [SerializeField] private Transform replyContainer;
         [SerializeField] private CanvasGroup dialogueCanvasGroup;
 
         [Header("Settings")] [SerializeField] private Language currentLanguage = Language.English;
         [SerializeField] private float textSpeed = 0.03f;
         [SerializeField] private float fadeInDuration = 0.3f;
         [SerializeField] private KeyCode advanceKey = KeyCode.Space;
 
         [Header("Audio")] [SerializeField] private AudioSource voiceAudioSource;
         [SerializeField] private AudioSource sfxAudioSource;
 
         // Current dialogue state
         private DialogueMessageBase currentMessage;
         private GameObject currentDialogueUI;
         private List<GameObject> activeReplyButtons = new List<GameObject>();
         private bool isTyping = false;
         private bool canAdvance = false;
         private Coroutine typingCoroutine;
 
         // Events
         public System.Action<DialogueSequence> OnDialogueStart;
         public System.Action OnDialogueEnd;
         public System.Action<DialogueMessageBase> OnMessageDisplay;
         public System.Action<DialogueReply> OnReplySelected;
 
         private static DialogueManager instance;
 
         public static DialogueManager Instance
         {
             get
             {
                 if (instance == null)
                     instance = FindObjectOfType<DialogueManager>();
                 return instance;
             }
         }
 
         public enum Language
         {
             English,
             Arabic
         }
 
         void Awake()
         {
             if (instance == null)
                 instance = this;
             else if (instance != this)
                 Destroy(gameObject);
             
             if (replyPanel != null)
                 Debug.Log("I hId it start ");
             replyPanel.SetActive(false);
 
             if (dialogueCanvasGroup != null)
                 dialogueCanvasGroup.alpha = 0;
         }
 
         void Start()
         {
     
         }
 
         void Update()
         {
             // Handle advance input
             if (canAdvance && !isTyping && Input.GetKeyDown(advanceKey))
             {
                 if (currentMessage != null && (currentMessage.replies == null || currentMessage.replies.Count == 0))
                 {
                     AdvanceDialogue();
                 }
             }
 
             // Skip typing animation
             if (isTyping && Input.GetKeyDown(advanceKey))
             {
                 CompleteTyping();
             }
         }
 
         public void StartDialogue(DialogueSequence sequence)
         {
             if (sequence == null || sequence.firstMessage == null)
             {
                 Debug.LogError("Invalid dialogue sequence!");
                 return;
             }
 
             OnDialogueStart?.Invoke(sequence);
 
             if (sequence.pauseGameDuringDialogue)
                 Time.timeScale = 0;
 
             ShowDialogueUI(true);
             DisplayMessage(sequence.firstMessage);
         }
 
         public void StartDialogue(DialogueMessageBase firstMessage)
         {
             if (firstMessage == null)
             {
                 Debug.LogError("Invalid dialogue message!");
                 return;
             }
 
             ShowDialogueUI(true);
             DisplayMessage(firstMessage);
         }
 
         private void DisplayMessage(DialogueMessageBase message)
         {
             if (message == null)
             {
                 EndDialogue();
                 return;
             }
 
             currentMessage = message;
             OnMessageDisplay?.Invoke(message);
 
             // Clear previous UI
             if (currentDialogueUI != null)
                 Destroy(currentDialogueUI);
 
             // Create appropriate prefab
             GameObject prefabToUse = currentLanguage == Language.English ? dialoguePrefabEN : dialoguePrefabAR;
             currentDialogueUI = Instantiate(prefabToUse, dialogueContainer);
 
             // Setup the dialogue UI
             DialogueUI dialogueUI = currentDialogueUI.GetComponent<DialogueUI>();
             if (dialogueUI != null)
             {
                 dialogueUI.Setup(message, currentLanguage == Language.Arabic);
 
                 // Start typing animation
                 if (typingCoroutine != null)
                     StopCoroutine(typingCoroutine);
                 typingCoroutine = StartCoroutine(TypeText(dialogueUI.messageText, message.messageText));
             }
 
             // Play voice clip
             if (message.voiceClip != null && voiceAudioSource != null)
             {
                 voiceAudioSource.clip = message.voiceClip;
                 voiceAudioSource.Play();
             }
 
             // Handle replies
             UpdateReplyPanel(message);
         }
 
         private IEnumerator TypeText(TextMeshProUGUI textComponent, string fullText)
         {
             isTyping = true;
             canAdvance = false;
             textComponent.text = "";
             ArabicTextMeshProUGUI arText;
            arText =  textComponent.gameObject.GetComponent<ArabicTextMeshProUGUI>() != null ? textComponent.gameObject.GetComponent<ArabicTextMeshProUGUI>() :  null;
             foreach (char c in fullText)
             {
                 if (arText != null) arText.arabicText += c;
                 else textComponent.text += c;
                 yield return new WaitForSecondsRealtime(textSpeed);
             }
 
             isTyping = false;
             canAdvance = true;
         }
 
         private void CompleteTyping()
         {
             if (typingCoroutine != null)
             {
                 StopCoroutine(typingCoroutine);
                 typingCoroutine = null;
             }
 
             if (currentDialogueUI != null)
             {
                 DialogueUI dialogueUI = currentDialogueUI.GetComponent<DialogueUI>();
                 if (dialogueUI != null && currentMessage != null)
                 {
                     dialogueUI.messageText.text = currentMessage.messageText;
                 }
             }
 
             isTyping = false;
             canAdvance = true;
         }
 
         private void UpdateReplyPanel(DialogueMessageBase message)
         {
             // Clear previous replies
             foreach (var btn in activeReplyButtons)
             {
                 Destroy(btn);
             }
 
             activeReplyButtons.Clear();
 
             Debug.Log(message.replies.Count);
             // Check if we have replies
             if (message.replies != null && message.replies.Count > 0)
             {
                 replyPanel.SetActive(true);
                 replyContainer.gameObject.SetActive(true);
                 
                 Debug.Log("message.replies.Count");
 
                 // Create reply buttons
                 foreach (var reply in message.replies)
                 {
                     if (reply == null) continue;
 
                     // Check conditions if needed
                     if (reply.requiresCondition && !CheckCondition(reply.conditionKey))
                         continue;
 
                     GameObject replyButton = Instantiate(replyPrefab, replyContainer);
                     ReplyButton replyBtn = replyButton.GetComponent<ReplyButton>();
 
                     if (replyBtn != null)
                     {
                         replyBtn.Setup(reply, () => SelectReply(reply));
                     }
 
                     activeReplyButtons.Add(replyButton);
                 }
             }
             else
             {
                 Debug.Log("I hId it else ");
                 replyPanel.SetActive(false);
             }
         }
 
         private void SelectReply(DialogueReply reply)
         {
             if (reply == null) return;
 
             OnReplySelected?.Invoke(reply);
 
             // Play reply audio if exists
             if (reply.replyAudioClip != null && sfxAudioSource != null)
             {
                 sfxAudioSource.PlayOneShot(reply.replyAudioClip);
             }
 
             // Hide reply panel
             Debug.Log("I hId it inSelectReply ");
                 
             replyPanel.SetActive(false);
 
             // Display next message
             DisplayMessage(reply.nextMessage);
         }
 
         private void AdvanceDialogue()
         {
             if (currentMessage != null && currentMessage.nextMessage != null)
             {
                 DisplayMessage(currentMessage.nextMessage);
             }
             else
             {
                 EndDialogue();
             }
         }
 
         private void EndDialogue()
         {
             ShowDialogueUI(false);
 
             if (currentDialogueUI != null)
                 Destroy(currentDialogueUI);
 
             currentMessage = null;
             Time.timeScale = 1;
 
             OnDialogueEnd?.Invoke();
         }
 
         private void ShowDialogueUI(bool show)
         {
             if (dialogueCanvasGroup != null)
             {
                 StartCoroutine(FadeCanvas(show));
             }
         }
 
         private IEnumerator FadeCanvas(bool fadeIn)
         {
             float targetAlpha = fadeIn ? 1 : 0;
             float startAlpha = dialogueCanvasGroup.alpha;
             float elapsed = 0;
 
             while (elapsed < fadeInDuration)
             {
                 elapsed += Time.unscaledDeltaTime;
                 dialogueCanvasGroup.alpha = Mathf.Lerp(startAlpha, targetAlpha, elapsed / fadeInDuration);
                 yield return null;
             }
 
             dialogueCanvasGroup.alpha = targetAlpha;
             dialogueCanvasGroup.interactable = fadeIn;
             dialogueCanvasGroup.blocksRaycasts = fadeIn;
         }
 
         private bool CheckCondition(string conditionKey)
         {
             // Implement your condition checking logic here
             // For example, checking player stats, quest progress, etc.
             // For now, return true as placeholder
             return true;
         }
 
         public void SetLanguage(Language language)
         {
             currentLanguage = language;
         }
     }
 }"
 "
 
using UnityEngine;
namespace AL_Arcade.DialogueSystem.Scripts
{
   public class DialogueTrigger : MonoBehaviour
{
    [Header("Dialogue")]
    public DialogueSequence dialogueSequence;
    public DialogueMessageBase singleMessage;
    
    [Header("Trigger Settings")]
    public bool triggerOnStart = false;
    public bool triggerOnCollision = false;
    public bool triggerOnInteract = true;
    public KeyCode interactKey = KeyCode.E;
    
    [Header("Visual Feedback")]
    public GameObject interactionPrompt;
    
    private bool playerInRange = false;
    private bool hasTriggered = false;
    
    void Start()
    {
        if (interactionPrompt != null)
            interactionPrompt.SetActive(false);
        
        if (triggerOnStart)
            TriggerDialogue();
    }
    
    void Update()
    {
        if (triggerOnInteract && playerInRange && Input.GetKeyDown(interactKey))
        {
            TriggerDialogue();
        }
    }
    
    void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            playerInRange = true;
            
            if (interactionPrompt != null && !hasTriggered)
                interactionPrompt.SetActive(true);
            
            if (triggerOnCollision)
                TriggerDialogue();
        }
    }
    
    void OnTriggerExit(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            playerInRange = false;
            
            if (interactionPrompt != null)
                interactionPrompt.SetActive(false);
        }
    }
    
    public void TriggerDialogue()
    {
        if (hasTriggered && !triggerOnInteract) return;
        
        if (DialogueManager.Instance != null)
        {
            if (dialogueSequence != null)
                DialogueManager.Instance.StartDialogue(dialogueSequence);
            else if (singleMessage != null)
                DialogueManager.Instance.StartDialogue(singleMessage);
        }
        
        hasTriggered = true;
        
        if (interactionPrompt != null)
            interactionPrompt.SetActive(false);
    }
}
}
 "
 "
 // ============================================
 // File: DialogueUI.cs - Simplified Version
 // ============================================
 
 using ALArcade.ArabicTMP;
 using UnityEngine;
 using UnityEngine.UI;
 using TMPro;
 
 namespace AL_Arcade.DialogueSystem.Scripts
 {
     public class DialogueUI : MonoBehaviour
     {
         [Header("UI Elements")] public Image characterSprite;
         public TextMeshProUGUI characterName;
         public TextMeshProUGUI messageText;
 
         // Simplified setup - no layout modifications needed
         public void Setup(DialogueMessageBase message, bool isRTL)
         {
             if (message == null) return;
 
             // Set character sprite
             if (characterSprite != null && message.characterSprite != null)
             {
                 characterSprite.sprite = message.characterSprite;
             }
 
             // Set character name
             if (characterName != null)
             {
                 if (characterName.GetComponent<ArabicTextMeshProUGUI>() != null)
                     characterName.GetComponent<ArabicTextMeshProUGUI>().arabicText = message.characterName;
                 else
                 {
                     characterName.text = message.characterName;
                 }
                 
             }
 
             // Set message text (text will be empty initially for typing effect)
             if (messageText != null)
             {
                 if (messageText.GetComponent<ArabicTextMeshProUGUI>() != null)
                     messageText.GetComponent<ArabicTextMeshProUGUI>().arabicText = " ";
                 // The actual text will be filled by the typing animation in DialogueManager
                 messageText.text = "";
             }
         }
 
         // Optional: Method to directly set the text without typing effect
         public void SetMessageTextDirect(string text)
         {
             if (messageText != null)
             {
                 if (characterName.GetComponent<ArabicTextMeshProUGUI>() != null)
                     characterName.GetComponent<ArabicTextMeshProUGUI>().arabicText = text;
                 else
                 {
                     characterName.text = text;
                 }
             }
         }
 
         // Optional: Show/hide character elements if needed
         public void ShowCharacterInfo(bool show)
         {
             if (characterSprite != null)
                 characterSprite.gameObject.SetActive(show);
 
             if (characterName != null)
                 characterName.gameObject.SetActive(show);
         }
     }
 }
 "
 "using System.Collections.Generic;
  using UnityEngine;
  using UnityEngine.UI;
  using System.Collections;
  using TMPro;
  namespace AL_Arcade.DialogueSystem.Scripts
  {
      public class ReplyButton : MonoBehaviour
      {
          [Header("UI Elements")]
          public TextMeshProUGUI replyText;
          public Button button;
          public Image backgroundImage;
      
          [Header("Visual Feedback")]
          public Color normalColor = Color.white;
          public Color hoverColor = Color.gray;
          public Color pressedColor = Color.gray;
      
          private System.Action onClickAction;
      
          public void Setup(DialogueReply reply, System.Action onClick)
          {
              if (reply == null) return;
          
              if (replyText != null)
                  replyText.text = reply.replyText;
          
              onClickAction = onClick;
          
              if (button != null)
              {
                  button.onClick.RemoveAllListeners();
                  button.onClick.AddListener(() => onClickAction?.Invoke());
              }
          }
      
          public void OnPointerEnter()
          {
              if (backgroundImage != null)
                  backgroundImage.color = hoverColor;
          }
      
          public void OnPointerExit()
          {
              if (backgroundImage != null)
                  backgroundImage.color = normalColor;
          }
      
          public void OnPointerDown()
          {
              if (backgroundImage != null)
                  backgroundImage.color = pressedColor;
          }
      }
  
  }"
  Scriptable Objects :
  "using UnityEngine;
   
   // English dialogue message
   [CreateAssetMenu(fileName = "DialogueMessage_EN", menuName = "Dialogue/Message (English)")]
   public class DialogueMessage : DialogueMessageBase
   {
       // English-specific settings can be added here if needed
   }"
   "using UnityEngine;
    
    // Arabic dialogue message
    [CreateAssetMenu(fileName = "DialogueMessage_AR", menuName = "Dialogue/Message (Arabic)")]
    public class DialogueMessageArabic : DialogueMessageBase
    {
        // Arabic-specific settings can be added here if needed
    }
    
    // Reply scriptable object (shared for both languages)
    
    // Dialogue sequence container
"
"using System.Collections.Generic;
 using UnityEngine;
 
 
 
 // Base class for dialogue messages
     public abstract class DialogueMessageBase : ScriptableObject
     {
         [Header("Character Information")] public Sprite characterSprite;
         public string characterName;
 
         [Header("Message Content")] [TextArea(3, 5)]
         public string messageText;
 
         public AudioClip voiceClip;
 
         [Header("Dialogue Flow")] public List<DialogueReply> replies = new List<DialogueReply>();
         public DialogueMessageBase nextMessage; // Used when there are no replies
     }
 
 
 
 
"
"
using UnityEngine;


    [CreateAssetMenu(fileName = "DialogueReply", menuName = "Dialogue/Reply")]
    public class DialogueReply : ScriptableObject
    {
        [TextArea(2, 3)] public string replyText;
        public AudioClip replyAudioClip;
        public DialogueMessageBase nextMessage;

        [Header("Optional Conditions")] public bool requiresCondition;
        public string conditionKey; // Can be used for quest/stat checks
    }


"
"
using UnityEngine;

[CreateAssetMenu(fileName = "DialogueSequence", menuName = "Dialogue/Sequence")]
public class DialogueSequence : ScriptableObject
{
    public string sequenceName;
    public DialogueMessageBase firstMessage;
    public bool pauseGameDuringDialogue = true;
}
"